﻿/*
做输入检验时可以使用的属性:
reg :string 检查时用的 regname.
min :number 最小值

max :number 最大值

required :boolean 是否需要输入

check :boolean 是否即时检查

inputcase :"upper" / "lower" 大写/小写
emptymsg :string 为空时的消息
errormsg :string 输入错误时的消息
*/

// 打开遍历器

if (window["PageWolkthrougher"]) PageWolkthrougher.walk = true;

//预定义的检查模式

var g_webCheckRegs = [
    { regname: "int", reg: "^[-+]?\\d+$", regcheck: "^[-+]?\\d*$", msg: "请输入整数。" },
    { regname: "decimal", reg: "^[-+]?\\d+(\\.\\d*)?$", regcheck: "^[-+]?\\d+(\\.\\d*)?$", msg: "您输入的小数不正确。" },
    { regname: "money", reg: "^\\d+(\\.\\d{0,2})?$", regcheck: "^\\d+(\\.\\d{0,2})?$", msg: "您输入的金额格式不正确，请重新输入。" },
    { regname: "url", reg: "\\w+://.+", regcheck: "", msg: "您输入的路径不正确。" }
// 在这里添加检查模式

/*{ regname: "int",  reg: "^\\-?\\d+$", regcheck: "^\\-?\\d*$", msg: "请输入整数." },*/
];

    var Web_Check = { // 页面输入检查

        invoke: function (sender, e) { // 被 PageWolkthrougher 调用的方法

            Web_Check.attach(sender);
        },

        attach: function (input) {
            // 此处最理想的做法是 attach event , 但是如果多此引用等原因可能会 attach 多次
            // 这里采用判断如果没有事件才进行检验,
            // 所以要注意, 如果已经有这些事件了, 事件检验将会失效.
            if (input.onkeyup == null) {
                input.onkeyup = Web_Check.doEvent;
            }
            if (input.onpaste == null) {
                input.onpaste = Web_Check.doEvent;
            }
            if (input.onblur == null) {
                input.onblur = Web_Check.doEvent;
            }

            //如果发现是要进行大小写控件,
            //让输入法失效，直接输入英文字母

            if (Web_Check.has(input, "inputcase")) {
                input.style.imeMode = "disabled";
            }
        },

        has: function (input, attrName) {
            return input.getAttribute(attrName) != null;
        },

        doEvent: function (evt) {
            var event = window.event || evt;
            var input = event.srcElement;
            var type = event.type;
            if (input.className != "com_error") input.oldClassName = input.className;

            var ret = Web_Check._doEvent(input, type, event);
            if (ret == true) {
                Web_Check._clearError(input);
            } else {
                Web_Check._markError(input);
            }
        },

        _doEvent: function (input, type, evt) {
            var event = window.event || evt;

            //得到触发元素的值。

            var strValue = input.value;

            var hasInputcase = Web_Check.has(input, "inputcase") && input.getAttribute("inputcase");
            var hasReg = Web_Check.has(input, "reg");
            var hasCheck = Web_Check.has(input, "check");

            /// inputcase ///
            if (type == "keyup") {	//如果是键盘抬起事件，得到按键的值

                if (hasInputcase && strValue.length > 0) {
                    var sLastChar = strValue.substr(strValue.length - 1);
                    if (hasInputcase == "upper") {	//如果定义了转换大写

                        if (/^[a-z]$/.test(sLastChar) == true)
                            input.value = strValue.toUpperCase();
                    } else if (hasInputcase == "lower") {	//如果定义了转换小写

                        if (/^[A-Z]$/.test(sLastChar) == true)
                            input.value = strValue.toLowerCase();
                    }
                }
            } else if (type == "paste") {
                var tempStr = window.clipboardData.getData("Text");
                if (hasInputcase) {
                    if (hasInputcase == "upper") {
                        tempStr = tempStr.toUpperCase();
                    } else if (hasInputcase == "lower") {
                        tempStr = tempStr.toLowerCase();
                    }
                }
                window.clipboardData.setData("Text", tempStr);
            } else if (type == "blur") {    // 失去焦点时再检查一次大小写转换
                if (hasInputcase) {
                    if (hasInputcase == "upper") {
                        if (/[a-z]/.test(strValue) == true)
                            input.value = strValue.toUpperCase();
                    } else if (hasInputcase == "lower") {
                        if (/[A-Z]/.test(strValue) == true)
                            input.value = strValue.toLowerCase();
                    }
                }
            }

            /// reg ///
            //如果触发元素的值为空，则表示用户没有输入，不接受检查。

            if (strValue == "") return true;
            //如果触发元素没有设置reg属性，则返回不进行任何检查。

            if (!hasReg) return true;
            //如果触发元素没有定义check属性，则在按键和粘贴事件中不做检查

            if (type == "keyup" || type == "paste") {
                if (!hasCheck) return true;
                if (input.getAttribute("check") != "true") return true;
            }

            //如果没有通过检查模式，出现的错误信息

            var msg = "";
            //得到检查模式

            var reg = input.getAttribute("reg");
            if (reg == "time") {    //如果校验类型为日期，则需要在调用Form.check()时进行校验

                return true;
            }
            //正则表达式对象

            var regExp = null;
            //从预定义的检查模式中查找正则表达式对象

            for (var i = 0; i < g_webCheckRegs.length; i++) {
                if (g_webCheckRegs[i].regname == reg) {
                    if ((type == "keyup" || type == "paste") && g_webCheckRegs[i].regcheck != "") {
                        regExp = new RegExp(g_webCheckRegs[i].regcheck); //查找到预定义的检查模式

                    } else {
                        regExp = new RegExp(g_webCheckRegs[i].reg); //查找到预定义的检查模式

                    }
                    msg = g_webCheckRegs[i].msg; 				//定义预定义的报错信息
                    break; //查找成功，退出循环

                }
            }
            if (regExp == null) {	//如果没有查找到预定义的检查模式，说明reg本身就为正则表达式对象。

                regExp = new RegExp(reg); //按照用户自定义的正则表达式生成正则表达式对象。

                msg = "输入错误，请重新检查"; 	//错误信息
            }

            //检查触发元素的值符合检查模式，直接返回。

            //	    input.title = regExp;
            if (regExp.test(strValue) == true) {
                return true;
            } else {
                Web_Check._cancelEvent();
            }

            /// error
            var hasErrormsg = Web_Check.has(input, "errormsg");
            if (type == "blur") {	//如果是失去焦点并且检查不通过，则需要出现错误警告框。

                //判断用户是否自己定义了错误信息

                if (hasErrormsg) msg = input.getAttribute("errormsg");
                //显示错误信息
                alert(msg);
                //将焦点重新聚回触发元素

                input.focus();
                input.select();
            }

            return false;
        },

        _markError: function (obj) {
            //obj.className = "com_error";
        },

        _clearError: function (obj) {
            obj.className = obj.oldClassName;
        },

        _cancelEvent: function (e) {
            e = e || window.event;
            e.returnValue = false;
            e.cancelBubble = true;
        },

        doCheck: function (objRoot) {
            objRoot = objRoot || document.body;
            var e = {};
            e.result = true;
            UIHelper.walkthrough(objRoot, "true", Number.MAX_VALUE, Web_Check.doCheck_callback, e);
            return e.result;
        },

        doCheck_callback: function (sender, e) {
            var input = sender;
            var msg = "";
            /* 为空检验 */
            if (input.editor_type) input.control.refresh();

            var isRequired = Web_Check.has(input, "required");
            if (isRequired) {                
                var isNull = true;
                if (input.value.length > 0) {
                    isNull = trim(input.value).length == 0;
                }
                if (isNull && input.getAttribute("required") == "true") {
                    msg = input.getAttribute("emptymsg") || "不能为空，请输入内容。";
                }
            }

            /* 最大最小值检验 */
            var hasMin = Web_Check.has(input, "min");
            var hasMax = Web_Check.has(input, "max");
            var min = hasMin ? eval(input.min) : null;
            var max = hasMax ? eval(input.max) : null;
            //处理最大值和最小值的范围
            if (hasMin && Number(input.value) < Number(min) && !msg) {
                msg = input.getAttribute("errormsg") || "输入值不能小于" + min;
            }
            if (hasMax && Number(input.value) > Number(max) && !msg) {
                msg = input.getAttribute("errormsg") || "输入值不能大于" + max;
            }
            if (input.Length != null && input.value.length > input.Length) {
                var msg = input.getAttribute("extmsg") || "长度不能超过" + input.Length + "！";
            }
            if (msg.length > 0) {
                alert(msg);
                e.doreturn = true;
                e.result = false;
                try { input.focus(); } catch (exp) { }
                try { input.select(); } catch (exp) { }
            }
        }
    };

if (!window.Form) { window.Form = new Object(); }
// 检查页面上从 objRoot 开始的所有元素，主要是做非空检查

window.Form.check = function(objRoot) {
    return Web_Check.doCheck(objRoot);
};
// 对 obj 的最大长度进行检查，通常用于对 MultiLine 的 TextBox 进行长度限制
window.Form.checkLength = function(obj, maxlen) {
    if (!obj || !obj.value || !obj.value.length) return true;

    if (obj.value.length > maxlen) {
        var msg = obj.getAttribute("extmsg") || "长度不能超过" + maxlen + "！";
        alert(msg);
        try { obj.focus(); } catch (exp) { }
        try { obj.select(); } catch (exp) { }
        return false;
    }
    return true;
};
//去掉字串左边的空格
function lTrim(str)
{
  if (str.charAt(0) == " ")
  {
    //如果字串左边第一个字符为空格
    str = str.slice(1);//将空格从字串中去掉
    //这一句也可改成 str = str.substring(1, str.length);
    str = lTrim(str);    //递归调用
  }
  return str;
}

//去掉字串右边的空格
function rTrim(str)
{
  var iLength;
  
  iLength = str.length;
  if (str.charAt(iLength - 1) == " ")
  {
    //如果字串右边第一个字符为空格
    str = str.slice(0, iLength - 1);//将空格从字串中去掉
    //这一句也可改成 str = str.substring(0, iLength - 1);
    str = rTrim(str);    //递归调用
  }
  return str;
}

//去掉字串两边的空格
function trim(str)
{
  return lTrim(rTrim(str));
}
